home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / assist2.arc / ASSIST2.C next >
Encoding:
C/C++ Source or Header  |  1988-06-29  |  24.6 KB  |  793 lines
  1. #include "assist2.h"
  2. #include "include.h"
  3. #include "gemdefs.h"
  4. #include "gembind.h"
  5.  
  6. #define FILENAME     "ASSIST2.RSC"
  7. #define ACCNAME          "  The Assistant "
  8.  
  9.  
  10. /****************************************************************/
  11. /***     If you have a battery backup of your systemclock     ***/
  12. /***  please tell the compiler witch timer keeps on running   ***/
  13. /***                  >>> System clock (GEM)                  ***/
  14. /***            >>> Keyboard processor clock (KEY)            ***/
  15. /****************************************************************/
  16.  
  17. #define GEM                0
  18.  
  19. /****************************************************************/
  20. /***       In Europa there is another date-format then        ***/
  21. /***                   there is in the USA                    ***/
  22. /***                define the date-format here               ***/
  23. /***                   >>> 31-12-87  (EUR)                    ***/
  24. /***                   >>> 12-31-87  (USA)                    ***/
  25. /****************************************************************/
  26.  
  27. #define EUR                0
  28.  
  29. /****************************************************************/
  30. /***               Decaration of the variables                ***/
  31. /****************************************************************/
  32.  
  33. OBJECT          *tree;
  34. int       contrl[12],intin[128],intout[128],ptsin[128],ptsout[128];
  35. int       in[11],out[57];
  36. extern    int gl_apid;
  37. short     btime=TRUE,bdate=FALSE,balarm=FALSE;
  38. char      td_string[18] = "00.00.00 00:00:00"; 
  39. char      *time_string="000000",*date_string="000000";
  40. char      wait[] = { 0xff, 20 ,0xff, 0 };
  41. int       first,vn,zh,button,wh;
  42. int               bx,by,bw,bh,xdesk,ydesk,wdesk,hdesk;
  43.  
  44.  
  45. int info_track;
  46. int info_sector;
  47. int info_side;
  48. long info_free;
  49. char info_name[14];
  50.  
  51.  
  52.  
  53. main()
  54. {
  55. register  long    time;    /*** use register for speed ***/
  56. register  char    temp;
  57. int       event,h;
  58.  
  59. int eind;
  60. char bfree[7];
  61. OBJECT  *tree;
  62. appl_init();
  63. first=TRUE;
  64.                     /********************************************/
  65.                     /*** Copy the time and date               ***/
  66.                     /*** From GEM (system) to BIOS (keyboard) ***/
  67.                     /*** or                                   ***/
  68.                     /*** From BIOS (keyboard) to GEM (system) ***/
  69.                     /********************************************/
  70. /*
  71. #ifdef GEM
  72. tel_bios(Tgetdate(),Tgettime()); 
  73. #else
  74. tel_gem(Gettime());
  75. #endif
  76.  
  77. */
  78. if(!rsrc_load(FILENAME))   /*** try to load the RSC-file ***/
  79.         {
  80.         form_alert(1,"[3][I'm sorry, but I can't find|the RESOURCE-file.][ #&%$*##&^ ]");
  81.         appl_exit();
  82.         }
  83. else
  84.         {
  85.         vn = graf_handle(&h,&zh,&h,&h);  zh -= 2; 
  86.         v_opnvwk(&h,&vn,out);
  87.         vst_color(vn,1);
  88.     wind_get(0,WF_WXYWH,&xdesk,&ydesk,&wdesk,&hdesk);
  89.                 /*** Put program-name into the desktop  ***/
  90.  
  91.         menu_register(gl_apid,ACCNAME);  
  92.         rsrc_gaddr(0,CLOCK,&tree);
  93.         set_text(tree,TIME,time_string);
  94.         set_text(tree,DATE,date_string);
  95.         while(TRUE)                  /*** means always ***/                      
  96.                 {
  97.                 time = Gettime();       /*** get the time and date ***/
  98.                              /*** from the keyboard ***/
  99.    
  100.                              /*get the second's*/
  101.                 temp = ((((char)time) & 0x1f)*2);
  102.                 convert_time(temp,15,4);
  103.      
  104.                              /*get the minutes*/
  105.                 time >>= 5;
  106.                 temp = ((char)time) & 0x3f;
  107.                 convert_time(temp,12,2);
  108.      
  109.                              /*get the hours*/
  110.                 time >>=6;
  111.                 temp = time & 0x1f;
  112.                 convert_time(temp,9,0);
  113.      
  114.                              /*get the day*/
  115.                 time >>=5;
  116.                 temp = ((char)time) & 0x1f;
  117.                 #ifdef EUR 
  118.                 convert_date(temp,0,0); /*Europe format*/
  119.                 #else
  120.                 convert_date(temp,3,2); /*USA format*/
  121.                 #endif     
  122.  
  123.                              /*get the month*/
  124.                 time >>=5;
  125.                 temp = ((char)time) & 0x0f; 
  126.                 #ifdef EUR
  127.                 convert_date(temp,3,2);
  128.                 #else
  129.                 convert_date(temp,0,0);
  130.                 #endif
  131.      
  132.                              /*get the year*/
  133.                 temp = ((char)((time >> 4) + 80L) % 100) & 0x7f;
  134.                 convert_date(temp,6,4);
  135.  
  136.                 rsrc_gaddr(0,CLOCK,&tree);
  137.  
  138.                     /********************************************/
  139.                     /*** if alarm is set then                 ***/
  140.                     /*** check if the timestring is the same  ***/
  141.                     /*** as the alarmstring.                  ***/
  142.                     /********************************************/
  143.  
  144.                 if (balarm==TRUE && (strncmp(( (TEDINFO *) (tree + ALARM)->ob_spec )->te_ptext,time_string,4))==0)
  145.                         {
  146.                         balarm=FALSE;        /*** set alarm off ***/
  147.                         setp(tree,ALARMON,NORMAL);
  148.                         setp(tree,ALARMOFF,SELECTED);
  149.                         ping();              /*** give some sound ***/
  150.                         do_dialog(ALERT1,0); /*** tel the user it's time ***/
  151.                         }               
  152.                 if (btime == TRUE && bdate == TRUE)
  153.                         {
  154.                              /*** display the      ***/
  155.                              /*** whole timestring ***/
  156.  
  157.                         v_gtext(vn,502,zh,td_string);
  158.                         }
  159.                 else
  160.                         {
  161.                         if (btime == TRUE &&  bdate == FALSE)
  162.                                 {
  163.                              /*** display only ***/
  164.                              /*** the date     ***/
  165.  
  166.                                 v_gtext(vn,574,zh,&td_string[9]);
  167.                                 }
  168.                         else
  169.                                 {
  170.                                 if (btime == FALSE && bdate == TRUE)
  171.                                         {
  172.                              /*** make an early end to   ***/
  173.                              /*** the string and display ***/
  174.                              /*** the time               ***/
  175.  
  176.                                         td_string[9]=0;
  177.                                         v_gtext(vn,574,zh,td_string);
  178.                                         }
  179.                                 }
  180.                         }
  181.                 if (((date_string[5]-'0')<7)&&( first==TRUE))
  182.                         {
  183.                         ping();
  184.                         first=FALSE;
  185.                         wnd_opn();
  186.                         clock();
  187.                         wnd_cls();
  188.                         }
  189.  
  190.                     /********************************************/
  191.                     /*** check wat's happening.               ***/
  192.                     /********************************************/
  193.  
  194.                 event = evnt_multi(MU_TIMER | MU_MESAG,0,0,0,0,0,0,0,0,0,0,0,
  195.                                         0,0,out,2000,0,&h,&h,&h,&h,&h,&h);
  196.                 if((event & MU_MESAG) && (*out == AC_OPEN))
  197.                         {
  198.                         wnd_opn();
  199.                         rsrc_gaddr(0,MAIN,&tree);
  200.                         eind = FALSE;
  201.                         while(eind != TRUE)
  202.                                 { 
  203.                                 ltoa(Malloc(-1L),bfree);
  204.                                 set_text(tree,MBFREE,bfree);
  205.                                 form_center(tree,&bx,&by,&bw,&bh);
  206.                                 form_dial(0,0,0,0,0,bx,by,bw,bh);
  207.                                 form_dial(1,0,0,0,0,bx,by,bw,bh);
  208.                                 objc_draw(tree,0,32,bx,by,bw,bh);
  209.                                 button=form_do(tree,0);
  210.                                 objc_change(tree,button,0,bx,by,bw,bh,NORMAL,0);
  211.                                 form_dial(3,0,0,0,0,bx,by,bw,bh);   /*** erase dialog ***/
  212.                                 switch(button)
  213.                                         {
  214.                 
  215.                                         case ABOUT:
  216.                                         do_dialog(INTRO,0);
  217.                                         break;
  218.                 
  219.                                         case MCLOCK:
  220.                                         clock();
  221.                                         break;
  222.                 
  223.                                         case MFORMAT:
  224.                                         format();
  225.                                         break;
  226.                 
  227.                                         case MAKEDIR:
  228.                                         makedir();
  229.                                         break;
  230.                 
  231.                                         case MINFOA:
  232.                                         case MINFOB:
  233.                                         disk_info(button-MINFOA);
  234.                                         break;
  235.                 
  236.                                         case MERASEA:
  237.                                         case MERASEB:
  238.                                         disk_erase(button-MERASEA);
  239.                                         break;
  240.                 
  241.                                         case MCANCEL:
  242.                                         eind=TRUE;
  243.                                         break;
  244.                                         }  /* end of switch */
  245.                                 }  /* end of while */
  246.                            wnd_cls();
  247.                         }
  248.                 }     
  249.         appl_exit();
  250.         }
  251. }
  252.  
  253.  
  254.  
  255. disk_erase(drive)
  256. int drive;
  257. {
  258. if (insert(drive)==OKINSERT)
  259.         {
  260.         if (get_info(drive)==TRUE)
  261.                 {
  262.                 make_boot(info_track,info_sector,info_side-1,drive,"ASSIST2 FMT");
  263.                 disk_info(drive);
  264.                 }
  265.         }
  266. }
  267.  
  268.  
  269.  
  270. disk_info(drive)
  271. int drive;
  272. {
  273. OBJECT  *tree;
  274. int again=TRUE;
  275. char    *track="00",*sector="00",*side="0",*free="000000";
  276.  
  277. rsrc_gaddr(0,DISKINFO,&tree);
  278. while (again == TRUE)
  279.         {
  280.         Fsfirst("$%&&&&.&^&",255);
  281.         again=FALSE;
  282.         info_name[0]=0;
  283.         if (get_info(drive)==TRUE)
  284.                 {
  285.                 ltoa((long)info_track,track);
  286.                 ltoa((long)info_sector,sector);
  287.                 ltoa((long)info_side,side);
  288.                 ltoa((long)info_free,free);
  289.                 set_text(tree,INFOTRAC,track);
  290.                 set_text(tree,INFOSECT,sector);
  291.                 set_text(tree,INFOSIDE,side);
  292.                 set_text(tree,INFOFREE,free);
  293.                 set_text(tree,INFONAME,info_name);
  294.                 do_dialog(DISKINFO,0);
  295.                 if (button == INFOAGAI) again=TRUE;
  296.                 }
  297.         }
  298. }
  299.  
  300.  
  301.  
  302. get_info(drive)
  303. int drive;
  304. {
  305. int dummy,error,old_drive;
  306. char  *buffer;
  307. long  buf[4];
  308. DTABUF *dtabuf;
  309. buffer = malloc(20000);
  310. dtabuf = (DTABUF *) Fgetdta();
  311. old_drive=Dgetdrv();
  312. Dsetdrv(drive);
  313. dummy=Floprd(buffer,0L,drive,1,0,0,1);
  314. if(dummy < 0)
  315.     { 
  316.     do_dialog(DISKERRO,0);
  317.     error=FALSE;
  318.     }
  319. else
  320.     {
  321.     if (Fsfirst("*.*",8)==0)
  322.         {
  323.         for(dummy=0; dummy<14; dummy++) info_name[dummy]=dtabuf->name[dummy];
  324.         info_name[dummy++]=0;
  325.         }       
  326.         Dfree(&buf,drive+1);
  327.         info_free=buf[0]*buf[2]*buf[3];
  328.         info_side=get_no(0x1a,buffer);
  329.         info_track=get_no(0x13,buffer)/(get_no(0x18,buffer) * get_no(0x1a,buffer));
  330.         info_sector=get_no(0x18,buffer);
  331.         error=TRUE;
  332.         }
  333. free(buffer);
  334. Dsetdrv(old_drive);
  335. return(error);
  336. }
  337.  
  338.  
  339.  
  340.  
  341. /****************************************************************/
  342. /***                 convert the integer time                 ***/
  343. /***                to ASCII and put that into                ***/
  344. /***                      two strings.                        ***/
  345. /****************************************************************/
  346. convert_time(time,n1,n2)
  347. register char time;
  348. int       n1,n2;
  349. {
  350. td_string[n1] = time_string[n2] = time /10 +'0';
  351. td_string[n1+1] = time_string[n2+1] = time %10 +'0';        
  352. }
  353.  
  354.  
  355. /****************************************************************/
  356. /***                 convert the integer date                 ***/
  357. /***                to ASCII and put that into                ***/
  358. /***                      two strings.                        ***/
  359. /****************************************************************/
  360. convert_date(date,n1,n2)
  361. register char date;
  362. int       n1,n2;
  363. {
  364. td_string[n1] = date_string[n2] = date / 10 + '0'; 
  365. td_string[n1+1] = date_string[n2+1] = date % 10 + '0';
  366. }
  367.  
  368.  
  369. /****************************************************************/
  370. /***          function to let the user set the date,          ***/
  371. /***          time and alarm and how to display it.           ***/
  372. /****************************************************************/
  373. clock()
  374. {
  375. char      date2[6],time2[6];
  376. int       time=0,date=0;
  377.  
  378.                              /*** copy the date and time     ***/
  379.                              /*** currently in the dialogbox ***/
  380. strcpy(date2,date_string);
  381. strcpy(time2,time_string);
  382.                              /*** ask for user respond ***/ 
  383. do_dialog(CLOCK,TIME);
  384.                              /*** set some controle var.'s ***/
  385. btime=selectp(tree,TIMEON);
  386. bdate=selectp(tree,DATEON);
  387. balarm=selectp(tree,ALARMON);
  388.                              /*** if exit is SETTIME    ***/
  389.                              /*** set the time and date ***/
  390. if (button == SETTIME)
  391.      {
  392.      time |= convert(time_string,0);
  393.      time <<=6;
  394.      time |= convert(time_string,2);
  395.      time <<=5;
  396.      time |= (convert(time_string,4)/2);
  397.      Tsettime(time);
  398.      date |= (convert(date_string,4)-80);
  399.      date <<=4;
  400. #ifdef EUR
  401.      date |= convert(date_string,2);
  402.      date <<=5;
  403.      date |= convert(date_string,0);
  404. #else
  405.      date |= convert(date_string,0);
  406.      date <<=5;
  407.      date |= convert(date_string,2);
  408. #endif
  409.      Tsetdate(date);
  410.      tel_bios(Tgetdate(),Tgettime()); 
  411.      }
  412. v_gtext(vn,502,zh,"                 "); /***clear the desktop***/
  413. }
  414.  
  415.  
  416.  
  417. /****************************************************************/
  418. /***    function to convert a 2byte-string into an integer    ***/
  419. /****************************************************************/
  420. convert(string,number)
  421. char *string;
  422. int number;
  423. {
  424. return((string[number]-'0')*10 +(string[number+1]-'0'));
  425. }
  426.  
  427.  
  428.  
  429.  
  430. /****************************************************************/
  431. /***               function to give some sound                ***/
  432. /****************************************************************/
  433. ping()
  434. {
  435. Cconout(7);
  436. while(Dosound(-1L));
  437. Dosound(wait);
  438. while(Dosound(-1L));
  439. Cconout(7);
  440. }
  441.  
  442.  
  443. /****************************************************************/
  444. /***function to get the time from GEM and send it to the bios ***/
  445. /****************************************************************/
  446. tel_bios(timedate)
  447. long      timedate;
  448. {
  449. Settime(timedate);
  450. }
  451.  
  452.  
  453. /****************************************************************/
  454. /***                   reverse of the above                   ***/
  455. /****************************************************************/
  456. tel_gem(date,time)
  457. int date,time;
  458. {
  459. Tsetdate(date);
  460. Tsettime(time);
  461. }
  462.  
  463.  
  464.  
  465. /****************************************************************/
  466. /***          function to set the state of an object          ***/
  467. /***                to NORMAL,SELECTED,......                 ***/
  468. /****************************************************************/
  469.  
  470. setp(tree,object,bit)
  471. OBJECT *tree;
  472. int         object,bit;
  473. {
  474. objc_change(tree,object,0,bx,by,bw,bh,bit,0);
  475. }
  476.  
  477.  
  478.  
  479. do_format(tr,se,si,dr,diskn)
  480. int tr,se,si,dr;
  481. char    *diskn;
  482. {
  483. OBJECT  *tree;
  484. int       dt,button;
  485. char      trs[2],sis[2],*buffer;
  486. sis[0]= '0';
  487. buffer = malloc(20000);
  488. rsrc_gaddr(0,GO,&tree);
  489.                              /*** set walking-bar to start ***/
  490. init_prog();
  491.                              /*** let some RSC-strings point ***/
  492.                              /*** to our own strings         ***/
  493. set_text(tree,GOTRACK,trs);
  494. set_text(tree,GOSIDE,sis);
  495.                              /*** display a dialog box ***/  
  496. form_center(tree,&bx,&by,&bw,&bh);      /*** get coordinates ***/
  497. form_dial(0,0,0,0,0,bx,by,bw,bh );  /*** reserve screen  ***/
  498. form_dial(1,0,0,0,0,bx,by,bw,bh);       /*** make growbox    ***/
  499. objc_draw(tree,0,MAX_DEPTH,bx,by,bw,bh);
  500. for(dt=0;dt<tr;dt++)
  501.      {
  502.                              /*** let the user see ***/
  503.                              /*** what's going on  ***/
  504.      set_prog((float)dt,(float)tr-1,bx,by,bw,bh);
  505.      ltoa((long)dt,trs);
  506.      objc_draw(tree,GOTRACK,0,bx,by,bw,bh);
  507.      objc_draw(tree,GOSIDE,0,bx,by,bw,bh);
  508.                              /*** and format side one ***/
  509.      button = Flopfmt(buffer,0L,dr,se,dt,0,01,0x87654321L,0xe5e5);
  510.                              /*** if asked for.   ***/
  511.                              /*** format side two ***/
  512.      if((si == 1) && (button == 0))
  513.           {
  514.           sis[0] +=1;
  515.           objc_draw(tree,GOSIDE,0,bx,by,bw,bh);
  516.           sis[0] -=1;
  517.           button = Flopfmt(buffer,0L,dr,se,dt,1,01,0x87654321L,0xe5e5);
  518.           }
  519.                              /*** if something goes wrong ***/
  520.                              /*** button is true           ***/
  521.      if(button != 0) dt = (tr+1);
  522.      }
  523. form_dial(3,0,0,0,0,bx,by,bw,bh);   /*** erase dialog ***/
  524. free(buffer);
  525. if (button == FALSE) make_boot(tr,se,si,dr,diskn);
  526. else do_dialog(DISKERRO,0);
  527. }
  528.  
  529.  
  530.  
  531.  
  532.  
  533. format()
  534. {
  535.  
  536. OBJECT          *tree;
  537. int     sectors,tracks=80,sides,drive,eind;
  538. char    *diskname="EXTENDEDFMT",*track="80";
  539.  
  540. rsrc_gaddr(0,EXFORMAT,&tree);
  541. set_text(tree,DISKNAME,diskname);
  542. set_text(tree,TRACKNUM,track);
  543. form_center(tree,&bx,&by,&bw,&bh);
  544. form_dial(0,0,0,0,0,bx,by,bw,bh);
  545. form_dial(1,0,0,0,0,bx,by,bw,bh);
  546. objc_draw(tree,0,32,bx,by,bw,bh);
  547. eind = FALSE;
  548. while(eind != TRUE)
  549.         { 
  550.         button=form_do(tree,DISKNAME);
  551.         objc_change(tree,button,0,bx,by,bw,bh,NORMAL,0);
  552.         switch(button){
  553.         
  554.                 case FORMAT:
  555.                 sides= selectp(tree,DS);
  556.                 drive= selectp(tree,DRIVEB);
  557.                 sectors=selectp(tree,SEC10)+9;
  558.                 form_dial(3,0,0,0,0,bx,by,bw,bh);   /*** erase dialog ***/
  559.                                 if (insert(drive)==OKINSERT)
  560.                         {
  561.                         do_format(tracks,sectors,sides,drive,diskname);
  562.                         disk_info(drive);
  563.                         }
  564.                 eind=TRUE;
  565.                 break;
  566.                 
  567.                 case CANCEL:
  568.                 eind=TRUE;
  569.                 form_dial(3,0,0,0,0,bx,by,bw,bh);   /*** erase dialog ***/
  570.                                 break;
  571.                 
  572.                                 
  573.                 case TRACKDWN:
  574.                 case TRACKUP:
  575.                 if ((button==TRACKUP)&(tracks<83)) tracks+=1;
  576.                 if ((button==TRACKDWN)&(tracks>80)) tracks-=1;
  577.                 ltoa((long)tracks,track);
  578.                 evnt_timer(100,0);
  579.                 objc_draw(tree,TRACKNUM,0,bx,by,bw,bh);
  580.                 break;
  581.                 
  582.                 }
  583.         }
  584. }
  585.  
  586.  
  587.  
  588. /****************************************************************/
  589. /***   function to set the width of the object used by the    ***/
  590. /***                progress-indicator to zero                ***/
  591. /****************************************************************/
  592. init_prog()
  593. {
  594. OBJECT         *tree;
  595.  
  596. rsrc_gaddr(0, GO, &tree);
  597. (tree + BAR)->ob_width = 0;
  598. }       
  599.  
  600.  
  601. insert(drive)
  602. int drive;
  603. {
  604. char *str_drive="X";
  605. OBJECT  *tree;
  606. rsrc_gaddr(0,INSERT,&tree);
  607. str_drive[0]=drive+'A';
  608. set_text(tree,AINSERT,str_drive);
  609. do_dialog(INSERT,0);
  610. return(button);
  611. }
  612.  
  613.  
  614. ltoa(number,string)
  615. long number;
  616. char *string;
  617. {
  618. sprintf(string,"%ld  ",number);
  619. }
  620.  
  621.  
  622.  
  623. /****************************************************************/
  624. /***         function to make an adjusted bootsector          ***/
  625. /****************************************************************/
  626.  
  627. make_boot(tr,se,si,dr,diskn)
  628. int tr,se,si,dr;
  629. char *diskn;
  630. {       
  631. int       total,dummy;
  632. char      *buffer;
  633. buffer=malloc(20000);   
  634.                     /*** Make a new bootsector and ***/
  635.                     /*** write is to disk          ***/
  636.  
  637. total=(tr * se);
  638. for(dummy=0; dummy<(se*512); *(buffer + dummy++)=0);
  639. Protobt(buffer,0x01000000L,(((tr>40)*2)+si),0);
  640. *(buffer + 0x13)=(total+(si ? total : 0)) &0xff;
  641. *(buffer + 0x14)=((total+(si ? total : 0)) >> 8) &0xff;
  642. *(buffer + 0x18)=se;
  643. Flopwr(buffer,0L,dr,1,0,0,se);
  644.  
  645. for(dummy=0; dummy<512; buffer[dummy++]=0);
  646. for (dummy=0; dummy<strlen(diskn); dummy++)
  647.         {
  648.     diskn[dummy]=toupper(diskn[dummy]);
  649.     }
  650. sprintf(buffer,diskn);
  651. buffer[11]=8;
  652. Flopwr(buffer,0L,dr,(12-se),(1-si),si,(se-4));
  653. free(buffer);
  654. }
  655.  
  656.  
  657. /****************************************************************/
  658. /***        function to check if an object is SELECTED        ***/
  659. /****************************************************************/
  660. selectp(tree,which)
  661. long           tree;
  662. int            which;
  663. {
  664. return statep(tree,which,SELECTED);
  665. }
  666.  
  667.  
  668.  
  669.  
  670. /****************************************************************/
  671. /***      function to set the width of an object              ***/
  672. /***  changing the width of an object and redraw that object  ***/
  673. /***             wil give us a process-indicator              ***/
  674. /****************************************************************/
  675. set_prog(value, maxc,x,y,w,h)
  676. float          value, maxc;
  677. int x,y,w,h;
  678. {
  679. OBJECT         *tree;
  680. GRECT          box;
  681.  
  682. rsrc_gaddr(0, GO, &tree);
  683. (tree + BAR)->ob_width=((((tree + BOX)->ob_width ) / maxc)  * value);
  684. objc_draw(tree,BAR,0,x,y,w,h);
  685. }       
  686.  
  687.  
  688.  
  689. set_text(tree,object,string)
  690. OBJECT         *tree;
  691. int            object;
  692. char           *string;
  693. {
  694. TEDINFO        *obspec;
  695.  
  696. obspec= (TEDINFO *) (tree +object)->ob_spec;
  697. obspec->te_ptext=string;
  698. obspec->te_txtlen=strlen(string)+1;
  699. }
  700.  
  701.  
  702.  
  703.  
  704.  
  705. /****************************************************************/
  706. /***          function to get the state of an object          ***/
  707. /***                to NORMAL,SELECTED,......                 ***/
  708. /****************************************************************/
  709.  
  710. statep(tree,which,bit)
  711. long           tree;
  712. int            which,bit;
  713. {
  714. return((LWGET(OB_STATE(which)) & bit) != FALSE);
  715. }
  716.  
  717.  
  718. /****************************************************************/
  719. /***      function to convert an integer in MSDOS-format      ***/
  720. /***                     to ATARI format                      ***/
  721. /****************************************************************/
  722. get_no(i,buffer)
  723. int i;
  724. char *buffer;
  725. {
  726. int       low,high;
  727. low = *(buffer + i); high = *(buffer+ i+1);
  728. if(low < 0) high += 1;
  729. return(low + (256*high));
  730. }
  731.  
  732. makedir()
  733. {
  734. OBJECT  *tree;
  735. char *path,*name="12345678.123\0";
  736. int  dummy;
  737. path = (char *)Malloc(40L);
  738. strcpy(name,"FILENAME.EXT\0");
  739. strcpy(path,"A:\\*.*\0");
  740. path[0]=(Dgetdrv()+'A');
  741. Dsetpath(path);
  742. fsel_input(path,name,&button);
  743. if (button==1)
  744.         {
  745.         for(dummy=strlen(path); dummy>0;dummy--)
  746.                 {
  747.                 if (path[dummy]=='\\')
  748.                         {
  749.                         path[dummy]=0;
  750.                         dummy=0;
  751.                         }
  752.                 }
  753.         Dsetdrv(path[0]-'A');
  754.         Dsetpath(path);
  755.         if(Dcreate(name)) do_dialog(DISKERRO,0);
  756.         }
  757. Mfree(path);
  758. }
  759.  
  760.  
  761.  
  762. /****************************************************************/
  763. /** function to get user-respond from a already drawn dialog.  **/
  764. /**            And to set the exitbutton to NORMAL.            **/
  765. /****************************************************************/
  766.  
  767. do_dialog(dialog,edit)
  768. int       dialog,edit;
  769. {
  770. rsrc_gaddr(0,dialog,&tree);
  771. form_center(tree,&bx,&by,&bw,&bh);      /*** get coordinates ***/
  772. form_dial(0,0,0,0,0,bx,by,bw,bh );  /*** reserve screen  ***/
  773. form_dial(1,0,0,0,0,bx,by,bw,bh);       /*** make growbox    ***/
  774. objc_draw(tree,0,MAX_DEPTH,bx,by,bw,bh);
  775. button = form_do(tree,edit);
  776. form_dial(2,0,0,0,0,bx,by,bw,bh);       /*** schrink box  ***/
  777. form_dial(3,0,0,0,0,bx,by,bw,bh);   /*** erase dialog ***/
  778. setp(tree,button,NORMAL);
  779. }
  780.  
  781. wnd_opn()
  782. {
  783. wh=wind_create(0,xdesk,ydesk,wdesk,hdesk);
  784. wind_open(wh,xdesk,ydesk,wdesk,hdesk);
  785. }
  786.  
  787. wnd_cls()
  788. {
  789. wind_close(wh);
  790. wind_delete(wh);                        
  791. }
  792.  
  793.